import crypto from 'crypto';
import https from 'https';
import fs from 'fs';
import yaml from 'js-yaml'
// 替换为你的 user_id 和 token
const userId = '';
const token = '';
const cron = '0 * * * * ?'; // 一分钟一次！
const apiUrl = 'https://afdian.com/api/open/query-order';
// const apiUrl = 'https://afdian.com/api/open/query-sponsor';
// YAML 配置文件路径
const configFilePath = './config/config/other.yaml';

export default class quanQian extends plugin {
    constructor() {
        super({
            name: 'AfdianQuanqian', // 插件名称
            dsc: '获取Afadian发电信息, 记录, 黑白名单管理, 到期提醒', // 插件描述
            event: 'message',
            priority: 114514,
            rule: [
                {
                    reg: "^#?圈钱$",        // 触发命令: #圈钱 或 圈钱
                    fnc: 'circleMoney',
                    permission: 'master' // 仅主人可调用
                },
                {
                    reg: "^#?刷新爱发电$",    // 触发命令: #刷新爱发电 或 刷新爱发电
                    fnc: 'renew_afd',
                    permission: 'master', // 仅主人可调用
                }
            ]
        });
         this.task = {
      name: '自动圈钱？',
      cron: cron,
      fnc: () => {
        this.circleMoney().then(r => logger.mark("圈钱完成"));
      },
    };
    }

   
    async circleMoney(e) {
        e.reply("开始获取发电信息...", true, { recallMsg: 10 }); // 回复开始获取信息，并自动撤回

        try {
            const result = await this.renew_afd(); // 调用 renew_afd 函数获取数据

            if (result.ec === 200) {
                logger.info('Afadian API 查询成功');
                logger.debug('sujson 数据:', JSON.stringify(result.data));

                // 加载 YAML 配置文件
                let config;
                try {
                    const yamlData = fs.readFileSync(configFilePath, 'utf8');
                    config = yaml.load(yamlData);
                } catch (err) {
                    logger.error('加载 YAML 配置文件失败:', err);
                    e.reply("加载配置文件失败，请查看控制台日志。", true);
                    return; // 配置文件加载失败，直接返回
                }

                let whiteGroup = config.whiteGroup || []; // 获取白名单群组，默认为空数组
                let blackGroup = config.blackGroup || []; // 获取黑名单群组，默认为空数组

                // 检查是否需要发送提醒消息以及更新黑/白名单
                for (const order of result.data) {
                    const groupId = order.remark; // 将 remark 字段视为群号

                    if (!groupId) { // 如果 remark 为空，则跳过黑白名单处理和提醒
                        logger.warn(`订单号: ${order.out_trade_no} 缺少群号 (remark)，跳过黑白名单处理和提醒。`);
                        continue; // 跳过当前订单
                    }

                    if (whiteGroup.includes(groupId)) { // 如果群组在白名单中，跳过黑名单和提醒
                        logger.debug(`群组 ${groupId} 在白名单中，跳过黑名单检查和提醒。`);
                        continue; // 跳过当前订单
                    }


                    if (order.expiryDate) { // 检查到期时间
                        const expiryDate = new Date(order.expiryDate);
                        const currentDate = new Date();

                        if (expiryDate < currentDate) { // 如果到期，加入黑名单并发送提醒
                            if (!blackGroup.includes(groupId)) {
                                blackGroup.push(groupId); // 加入黑名单
                                logger.info(`群组 ${groupId} (订单号: ${order.out_trade_no}) 已加入黑名单，因发电到期。`);
                            }
                            Bot.pickgroup(groupId).sendMsg("该打钱了，注意续费！"); // 发送提醒消息
                            logger.info(`已向群 ${groupId} 发送打钱提醒，订单号: ${order.out_trade_no}, 到期日: ${order.expiryDate}`);

                        }
                    }

                    // 新发电记录，加入白名单并移除黑名单 (如果存在)
                    if (!whiteGroup.includes(groupId)) {
                        whiteGroup.push(groupId); // 加入白名单
                        logger.info(`群组 ${groupId} (订单号: ${order.out_trade_no}) 已加入白名单，因有新的发电记录。`);
                    }
                    const blackIndex = blackGroup.indexOf(groupId);
                    if (blackIndex > -1) {
                        blackGroup.splice(blackIndex, 1); // 从黑名单移除
                        logger.info(`群组 ${groupId} (订单号: ${order.out_trade_no}) 已从黑名单移除，因有新的发电记录。`);
                    }
                }

                // 更新 YAML 配置文件
                config.whiteGroup = whiteGroup;
                config.blackGroup = blackGroup;
                try {
                    const yamlStr = yaml.dump(config);
                    fs.writeFileSync(configFilePath, yamlStr, 'utf8');
                    logger.info('YAML 配置文件更新成功');
                } catch (err) {
                    logger.error('更新 YAML 配置文件失败:', err);
                    e.reply("更新配置文件失败，请查看控制台日志。", true);
                    return; // 配置文件更新失败，返回
                }


                const filename = 'afd.json';         // 定义 JSON 文件名
                const filePath = './data/afd/afd.json';  // 定义 JSON 文件路径

                // 确保目录存在
                const dirPath = './data/afd';
                if (!fs.existsSync(dirPath)) {
                    fs.mkdirSync(dirPath, { recursive: true });
                    logger.info(`目录 ${dirPath} 创建成功`);
                }

                try {
                    fs.writeFileSync(filePath, JSON.stringify(result.data, null, 2)); // 写入 JSON 文件
                    logger.info(`数据已成功写入到 ${filePath}`);
                } catch (err) {
                    logger.error('写入 JSON 文件失败:', err);
                    e.reply("发电信息获取成功，但写入文件时发生错误，请查看控制台日志。", true);
                    return;
                }

                e.reply("发电信息获取成功，并已写入文件及更新黑白名单，请查看控制台日志或文件。", true);

            } else {
                logger.error('Afadian API 查询失败!');
                logger.error('错误码:', result.ec, '错误信息:', result.em);
                if (result.data && result.data.debug && result.data.debug.kv_string) {
                    logger.error('签名调试信息 (kv_string):', result.data.debug.kv_string);
                }
                e.reply("发电信息获取失败，请查看控制台日志或联系管理员。", true);
            }

        } catch (error) {
            logger.error('renew_afd 函数执行出错:', error);
            if (error && error.rawData) {
                logger.error('原始响应数据:', error.rawData);
            }
            e.reply("获取发电信息时发生错误，请查看控制台日志或联系管理员。", true);
        }
    }

    async renew_afd() {
        //  params 参数 (函数内部，可以根据需要修改默认参数)
        const paramsData = { page: 1 }; // 默认查询第一页订单
        // const paramsData = { page: 1, per_page: 10 }; // 可以修改 per_page 参数

        const ts = Math.floor(Date.now() / 1000); // 获取当前秒级时间戳
        const params = JSON.stringify(paramsData); // params 参数 JSON 字符串化

        // 计算签名
        const signRawString = token + 'params' + params + 'ts' + ts + 'user_id' + userId;
        const sign = crypto.createHash('md5').update(signRawString).digest('hex');

        const requestData = JSON.stringify({
            user_id: userId,
            params: params,
            ts: ts,
            sign: sign
        });

        const options = {
            method: 'POST', // 使用 POST 方法
            headers: {
                'Content-Type': 'application/json'
            }
        };

        return new Promise((resolve, reject) => { // 使用 Promise 封装异步请求
            const req = https.request(apiUrl, options, (res) => {
                let responseData = '';

                res.on('data', (chunk) => {
                    responseData += chunk;
                });

                res.on('end', () => {
                    try {
                        const parsedData = JSON.parse(responseData);
                        if (parsedData.ec === 200) {
                            const sujson = []; // 初始化 sujson 数组
                            if (parsedData.data && parsedData.data.list) {
                                parsedData.data.list.forEach(order => {
                                    let orderDate = "日期解析失败";
                                    let expiryDate = "日期解析失败"; // 初始化到期时间

                                    if (order.out_trade_no && order.out_trade_no.length >= 8) {
                                        const dateString = order.out_trade_no.substring(0, 8);
                                        const year = dateString.substring(0, 4);
                                        const month = dateString.substring(4, 6);
                                        const day = dateString.substring(6, 8);
                                        orderDate = `${year}年${month}月${day}日`;

                                        // 计算到期时间
                                        const startDate = new Date(`${year}-${month}-${day}`); // 使用 ISO 格式方便 Date 解析
                                        const durationMonths = parseInt(order.month, 10) || 0; // 确保 month 是数字，默认为 0
                                        const newExpiryDate = new Date(startDate);
                                        newExpiryDate.setMonth(startDate.getMonth() + durationMonths);

                                        const expiryYear = newExpiryDate.getFullYear();
                                        const expiryMonth = String(newExpiryDate.getMonth() + 1).padStart(2, '0'); // 月份从 0 开始，需要 +1，并补零
                                        const expiryDay = String(newExpiryDate.getDate()).padStart(2, '0'); // 日期补零
                                        expiryDate = `${expiryYear}年${expiryMonth}月${expiryDay}日`; // 格式化到期时间
                                    }


                                    const powerDuration = order.month;
                                    const remark = order.remark;

                                    sujson.push({ // 将提取的信息存储到 sujson 数组
                                        orderDate: orderDate,
                                        powerDuration: powerDuration,
                                        remark: remark,
                                        out_trade_no: order.out_trade_no, // 可选: 订单号
                                        plan_id: order.plan_id,           // 可选: 方案ID
                                        sku_detail: order.sku_detail,      // 可选: 售卖方案型号详情
                                        expiryDate: expiryDate             // 添加到期时间字段
                                    });
                                })
                                resolve({ ec: 200, data: sujson }); // 请求成功，resolve 状态码和 sujson 数据
                            } else {
                                resolve({ ec: 200, data: [] }); //  API 成功但 data 或 list 为空，仍然 resolve, 返回空数组
                            }
                        } else {
                            reject({ ec: parsedData.ec, em: parsedData.em, data: parsedData.data }); // 请求失败，reject 错误信息
                        }
                    } catch (e) {
                        reject({ ec: -1, em: 'JSON 解析错误', error: e, rawData: responseData }); // JSON 解析错误，reject 错误信息
                    }
                });
            });

            req.on('error', (error) => {
                reject({ ec: -2, em: '请求错误', error: error }); // 网络请求错误，reject 错误信息
            });

            req.write(requestData);
            req.end();
        });
    }
}
